// import { Component, instantiate, Node, Prefab, Widget, Canvas, Camera } from 'cc';
// import { BaseModule } from './base/BaseModule';
// import { GameFramework } from './base/GameFramework';
// import { GameEvent } from '../../game/configs/GameEvent';

// export enum UILayer {
//     BACKGROUND = 0,
//     MAIN = 1,
//     POPUP = 2,
//     TOOLTIP = 3,
//     LOADING = 4
// }

// export class BaseWindow extends Component {
//     protected _uiName: string = "";
//     protected _isOpened: boolean = false;
//     protected _layer: UILayer = UILayer.MAIN;
//     protected widget: Widget | null = null;

//     init() {
//         this.widget = this.getComponent(Widget) || this.addComponent(Widget);
//         this.widget.alignMode = Widget.AlignMode.ON_WINDOW_RESIZE;
//         this.widget.target = this.node.parent;
//     }

//     // 窗口打开时调用
//     onOpen(data?: any) {
//         // 子类可重写
//     }

//     // 窗口关闭时调用
//     onClose() {
//         // 子类可重写
//     }

//     // 窗口显示时调用（从隐藏到显示）
//     onShow() {
//         // 子类可重写
//     }

//     // 窗口隐藏时调用（从显示到隐藏）
//     onHide() {
//         // 子类可重写
//     }

//     open(data?: any) {
//         this.node.active = true;
//         this._isOpened = true;
//         this.onOpen(data);
//         GameFramework.event.emit(GameEvent.UI_OPEN, this._uiName);
//     }

//     close() {
//         this.node.active = false;
//         this._isOpened = false;
//         this.onClose();
//         GameFramework.event.emit(GameEvent.UI_CLOSE, this._uiName);
//     }

//     show() {
//         if (!this._isOpened) return;
//         this.node.active = true;
//         this.onShow();
//         GameFramework.event.emit(GameEvent.UI_SHOW, this._uiName);
//     }

//     hide() {
//         if (!this._isOpened) return;
//         this.node.active = false;
//         this.onHide();
//         GameFramework.event.emit(GameEvent.UI_HIDE, this._uiName);
//     }

//     isOpened(): boolean {
//         return this._isOpened;
//     }

//     getLayer(): UILayer {
//         return this._layer;
//     }

//     setLayer(layer: UILayer) {
//         this._layer = layer;
//     }
// }

// export class UIManager extends BaseModule {
//     private _windows: Map<string, BaseWindow> = new Map();
//     private _windowStack: BaseWindow[] = [];
//     private _uiRoot: Node | null = null;
//     private _uiCamera: Camera | null = null;
//     private _uiLayers: Map<UILayer, Node> = new Map();

//     init() {
//         // 初始化UI管理器
//         this._uiRoot = GameFramework.instance.node.getChildByName('UIManager');
        
//         // 如果没有找到，则创建新的UIManager节点
//         if (!this._uiRoot) {
//             this._uiRoot = new Node('UIManager');
//             GameFramework.instance.addChild(this._uiRoot);
            
//             // 创建UI相机
//             const cameraNode = new Node("UICamera");
//             this._uiCamera = cameraNode.addComponent(Camera);
//             this._uiCamera.priority = 1;
//             this._uiRoot.addChild(cameraNode);
//         } else {
//             // 获取已有的相机组件
//             const cameraNode = this._uiRoot.getChildByName("UICamera");
//             this._uiCamera = cameraNode?.getComponent(Camera) || null;
//         }
        
//         this.setUIRoot(this._uiRoot);
//     }
    
//     shutdown(): void {
//         // 清理所有窗口
//         this.closeAllWindows();
//         this._windows.clear();
//         this._windowStack.length = 0;
//         this._uiLayers.clear();
//         this._uiCamera = null;
//         this._uiRoot = null;
//     }

//     setUIRoot(root: Node) {
//         if (!root) {
//             console.error("UI Root cannot be null");
//             return;
//         }
        
//         this._uiRoot = root;
//         this._initUILayers();
//     }

//     private _initUILayers() {
//         if (!this._uiRoot) {
//             console.warn("UI Root is not set, cannot initialize UI layers");
//             return;
//         }

//         // 确保根节点有 Canvas 组件
//         if (!this._uiRoot.getComponent(Canvas)) {
//             const canvas = this._uiRoot.addComponent(Canvas);
//             // 设置相机关联
//             if (this._uiCamera) {
//                 canvas.cameraComponent = this._uiCamera;
//             }
//         }

//         // 创建各个 UI 层
//         for (let layer = UILayer.BACKGROUND; layer <= UILayer.LOADING; layer++) {
//             let layerNode = this._uiRoot.getChildByName(UILayer[layer]);
//             if (!layerNode) {
//                 layerNode = new Node(UILayer[layer]);
//                 this._uiRoot.addChild(layerNode);
                
//                 // 添加 Widget 组件以确保正确布局
//                 const widget = layerNode.addComponent(Widget);
//                 widget.alignMode = Widget.AlignMode.ON_WINDOW_RESIZE;
//                 widget.left = 0;
//                 widget.right = 0;
//                 widget.top = 0;
//                 widget.bottom = 0;
//             }
//             this._uiLayers.set(layer, layerNode);
//         }
//     }

//     private _getLayerNode(layer: UILayer): Node | null {
//         return this._uiLayers.get(layer) || null;
//     }

//     async openWindow(uiName: string, data?: any, layer: UILayer = UILayer.MAIN): Promise<BaseWindow | null> {
//         try {
//             // 检查UI根节点是否存在
//             if (!this._uiRoot) {
//                 console.error("UI Root is not set");
//                 return null;
//             }

//             // 如果窗口已存在且已打开，则直接显示
//             if (this._windows.has(uiName)) {
//                 const window = this._windows.get(uiName)!;
//                 if (!window.isOpened()) {
//                     window.open(data);
//                     this._windowStack.push(window);
//                 } else {
//                     window.show();
//                 }
//                 return window;
//             }

//             // 加载窗口预制体
//             const prefabPath = `ui/${uiName}`;
//             const prefab = await GameFramework.resource.load<Prefab>(prefabPath, Prefab);
//             const node = instantiate(prefab);
            
//             // 获取窗口脚本组件
//             const script = node.getComponent(BaseWindow);
//             if (!script) {
//                 console.error(`窗口 ${uiName} 缺少 BaseWindow 组件`);
//                 node.destroy();
//                 return null;
//             }
            
//             // 设置窗口层级
//             script.setLayer(layer);
            
//             // 添加到对应的 UI 层节点下
//             const layerNode = this._getLayerNode(layer);
//             if (layerNode) {
//                 layerNode.addChild(node);
//             } else if (this._uiRoot) {
//                 this._uiRoot.addChild(node);
//             } else {
//                 GameFramework.instance.addChild(node);
//             }
            
//             script.init();
//             script["_uiName"] = uiName;
//             this._windows.set(uiName, script);
//             script.open(data);
//             this._windowStack.push(script);
            
//             return script;
//         } catch (error) {
//             console.error(`打开窗口 ${uiName} 失败:`, error);
//             return null;
//         }
//     }

//     closeWindow(uiName: string) {
//         const window = this._windows.get(uiName);
//         if (window) {
//             window.close();
            
//             // 从窗口栈中移除
//             const index = this._windowStack.indexOf(window);
//             if (index !== -1) {
//                 this._windowStack.splice(index, 1);
//             }
            
//             // 从窗口映射中移除
//             this._windows.delete(uiName);
//         }
//     }

//     closeTopWindow() {
//         const window = this._windowStack.pop();
//         if (window) {
//             window.close();
//             // 从窗口映射中移除
//             this._windows.delete(window["_uiName"]);
//         }
//     }

//     getWindow(uiName: string): BaseWindow | undefined {
//         return this._windows.get(uiName);
//     }

//     // 关闭所有窗口
//     closeAllWindows() {
//         // 创建窗口数组副本，避免在迭代过程中修改集合
//         const windowsToClose = Array.from(this._windows.values());
//         for (const window of windowsToClose) {
//             window.close();
//         }
//         this._windowStack.length = 0;
//         this._windows.clear();
//     }

//     /**
//      * 显示消息提示框
//      * @param title 标题
//      * @param content 内容
//      * @param onConfirm 确认回调
//      * @param onCancel 取消回调
//      * @param showCancel 是否显示取消按钮
//      */
//     public async showMessage(
//         title: string, 
//         content: string, 
//         onConfirm?: () => void, 
//         onCancel?: () => void,
//         showCancel: boolean = true
//     ): Promise<void> {
//         await GameFramework.ui.openWindow("MessageBox", {
//             title,
//             content,
//             onConfirm,
//             onCancel,
//             showCancel
//         }, UILayer.TOOLTIP);
//     }

//     /**
//      * 显示输入框
//      * @param title 标题
//      * @param description 描述
//      * @param defaultValue 默认值
//      * @param onConfirm 确认回调（返回输入内容）
//      * @param onCancel 取消回调
//      */
//     public async showInput(
//         title: string,
//         description: string,
//         defaultValue: string,
//         onConfirm?: (input: string) => void,
//         onCancel?: () => void
//     ): Promise<void> {
//         await GameFramework.ui.openWindow("InputBox", {
//             title,
//             description,
//             defaultValue,
//             onConfirm,
//             onCancel
//         }, UILayer.TOOLTIP);
//     }

//     /**
//      * 显示Toast提示
//      * @param message 消息内容
//      * @param duration 显示时长（秒）
//      * @param type 类型（success, error, warning, info）
//      */
//     public async showToast(
//         message: string,
//         duration: number = 2,
//         type: string = "info"
//     ): Promise<void> {
//         await GameFramework.ui.openWindow("Toast", {
//             message,
//             duration,
//             type
//         }, UILayer.LOADING);
//     }

//     /**
//      * 显示确认对话框
//      * @param title 标题
//      * @param content 内容
//      * @param onOk 确定回调
//      * @param onNo 否定回调
//      * @param onCancel 取消回调
//      * @param showNo 是否显示"否"按钮
//      * @param showCancel 是否显示取消按钮
//      */
//     public async showConfirm(
//         title: string,
//         content: string,
//         onOk?: () => void,
//         onNo?: () => void,
//         onCancel?: () => void,
//         showNo: boolean = true,
//         showCancel: boolean = true
//     ): Promise<void> {
//         await GameFramework.ui.openWindow("ConfirmDialog", {
//             title,
//             content,
//             onOk,
//             onNo,
//             onCancel,
//             showNo,
//             showCancel
//         }, UILayer.TOOLTIP);
//     }
// }

import { Component, instantiate, Node, Prefab, Widget, Canvas, Camera } from 'cc';
import { ResourceSystem } from './ResourceSystem';
import { BaseModule, IModule } from './base/BaseModule';
import { GameFramework } from './base/GameFramework';
import { GameEvent } from '../../game/configs/GameEvent';

export enum UILayer {
    BACKGROUND = 0, // 背景层，最底层UI
    MAIN = 1,       // 主界面层，游戏主要UI
    POPUP = 2,      // 弹窗层，各类弹出窗口
    TOOLTIP = 3,    // 提示层，显示提示、确认框等
    LOADING = 4     // 加载层，显示加载提示，最顶层
}

/**
 * 窗口数据接口
 * 定义传递给窗口的数据结构
 */
export interface IWindowData {
    [key: string]: any;
}

/**
 * 窗口选项接口
 * 定义打开窗口时的配置选项
 */
export interface IWindowOptions {
    layer?: UILayer; // 指定窗口所在层级
    [key: string]: any;
}

/**
 * 窗口视图接口
 * 定义窗口组件必须实现的方法
 */
export interface IWindowView {
    node: Node;
    init(): void;
    open(data?: IWindowData): void;
    close(): void;
    show(): void;
    hide(): void;
    isOpened(): boolean;
    getLayer(): UILayer;
    setLayer(layer: UILayer): void;
}


/**
 * 窗口管理器接口
 * 定义窗口管理器必须实现的方法
 */
export interface IWindowManager {
    openWindow(uiName: string, data?: IWindowData, options?: IWindowOptions): Promise<IWindowView | null>;
    closeWindow(uiName: string): void;
    closeTopWindow(): void;
    closeAllWindows(): void;
    getWindow(uiName: string): IWindowView | undefined;
    showMessage(title: string, content: string, onConfirm?: () => void, onCancel?: () => void, showCancel?: boolean): Promise<void>;
    showInput(title: string, description: string, defaultValue: string, onConfirm?: (input: string) => void, onCancel?: () => void): Promise<void>;
    showToast(message: string, duration?: number, type?: string): Promise<void>;
    showConfirm(title: string, content: string, onOk?: () => void, onNo?: () => void, onCancel?: () => void, showNo?: boolean, showCancel?: boolean): Promise<void>;
}


export class BaseWindow extends Component implements IWindowView {
    // 声明窗口名称
    protected _uiName: string = "";
    // 声明窗口是否打开
    protected _isOpened: boolean = false;
    // 声明窗口所在的层级
    protected _layer: UILayer = UILayer.MAIN;
    // 声明窗口的组件
    protected widget: Widget | null = null;

    // 初始化窗口
    init() {
        // 获取窗口组件
        this.widget = this.getComponent(Widget) || this.addComponent(Widget);
        // 设置窗口组件的对齐方式
        this.widget.alignMode = Widget.AlignMode.ONCE;
        // 设置窗口组件的父节点
        this.widget.target = this.node.parent;
    }

    // 打开窗口
    onOpen(data?: IWindowData) {}
    // 关闭窗口
    onClose() {}
    // 显示窗口
    onShow() {}
    // 隐藏窗口
    onHide() {}

    // 打开窗口
    open(data?: IWindowData) {
        // 设置窗口为激活状态
        this.node.active = true;
        // 设置窗口为打开状态
        this._isOpened = true;
        // 触发打开窗口事件
        this.onOpen(data);
        // 触发UI打开事件
        GameFramework.event.emit(GameEvent.UI_OPEN, this._uiName);
    }

    // 关闭窗口
    close() {
        // 设置窗口为非激活状态
        this.node.active = false;
        // 设置窗口为关闭状态
        this._isOpened = false;
        // 触发关闭窗口事件
        this.onClose();
        // 触发UI关闭事件
        GameFramework.event.emit(GameEvent.UI_CLOSE, this._uiName);
    }

    // 显示窗口
    show() {
        // 如果窗口打开，则设置窗口为激活状态
        if (this._isOpened) {
            this.node.active = true;
            // 触发显示窗口事件
            this.onShow();
            // 触发UI显示事件
            GameFramework.event.emit(GameEvent.UI_SHOW, this._uiName);
        }
    }

    // 隐藏窗口
    hide() {
        // 如果窗口打开，则设置窗口为非激活状态
        if (this._isOpened) {
            this.node.active = false;
            // 触发隐藏窗口事件
            this.onHide();
            // 触发UI隐藏事件
            GameFramework.event.emit(GameEvent.UI_HIDE, this._uiName);
        }
    }

    // 获取窗口是否打开
    isOpened(): boolean { return this._isOpened; }
    // 获取窗口所在层级
    getLayer(): UILayer { return this._layer; }
    // 设置窗口所在层级
    setLayer(layer: UILayer) { this._layer = layer; }
    
    // 添加获取窗口名称的方法
    getUIName(): string { return this._uiName; }
    // 添加设置窗口名称的方法
    setUIName(name: string) { this._uiName = name; }
}

// 窗口数据管理器 - 负责处理窗口数据
// 导出一个WindowManagerData类
export class WindowManagerData {
    // 定义一个Map类型的私有变量，用于存储窗口
    private _windows: Map<string, IWindowView> = new Map();
    // 定义一个数组类型的私有变量，用于存储窗口栈
    private _windowStack: IWindowView[] = [];
    
    // 添加窗口到Map中
    addWindow(uiName: string, window: IWindowView): void {
        this._windows.set(uiName, window);
    }
    
    // 从Map中删除窗口
    removeWindow(uiName: string): boolean {
        return this._windows.delete(uiName);
    }
    
    // 从Map中获取窗口
    getWindow(uiName: string): IWindowView | undefined {
        return this._windows.get(uiName);
    }
    
    // 判断Map中是否存在窗口
    hasWindow(uiName: string): boolean {
        return this._windows.has(uiName);
    }
    
    // 将窗口压入窗口栈
    pushToStack(window: IWindowView): void {
        this._windowStack.push(window);
    }
    
    // 从窗口栈中弹出窗口
    popFromStack(): IWindowView | undefined {
        return this._windowStack.pop();
    }
    
    // 从窗口栈中删除窗口
    removeFromStack(window: IWindowView): void {
        const index = this._windowStack.indexOf(window);
        if (index !== -1) {
            this._windowStack.splice(index, 1);
        }
    }
    
    // 关闭所有窗口
    closeAllWindows(): void {
        this._windows.forEach(window => window.close());
        this._windowStack.length = 0;
        this._windows.clear();
    }
    
    // 获取所有窗口
    getAllWindows(): Map<string, IWindowView> {
        return new Map(this._windows);
    }
}

// UI层级管理器 - 负责管理UI层级结构
export class UILayerManager {
    // 定义一个Map，用于存储UILayer和Node的对应关系
    private _uiLayers: Map<UILayer, Node> = new Map();
    // 定义一个Node，用于存储UI根节点
    private _uiRoot: Node | null = null;
    // 定义一个Camera，用于存储UI相机
    private _uiCamera: Camera | null = null;
    
    // 构造函数，用于初始化UI根节点和UI相机
    constructor(uiRoot: Node | null = null, uiCamera: Camera | null = null) {
        this._uiRoot = uiRoot;
        this._uiCamera = uiCamera;
    }
    
    // 设置UI根节点
    setUIRoot(root: Node): void {
        if (!root) {
            console.error("UI Root cannot be null");
            return;
        }
        this._uiRoot = root;
        this._initUILayers();
    }
    
    // 获取UI根节点
    getUIRoot(): Node | null {
        return this._uiRoot;
    }
    
    // 设置UI相机
    setUICamera(camera: Camera | null): void {
        this._uiCamera = camera;
    }
    
    // 获取指定UILayer的Node
    getLayerNode(layer: UILayer): Node | null {
        return this._uiLayers.get(layer) || null;
    }
    
    // 初始化UI层
    private _initUILayers(): void {
        if (!this._uiRoot) {
            console.warn("UI Root is not set, cannot initialize UI layers");
            return;
        }

        // 如果UI根节点没有Canvas组件，则添加Canvas组件
        if (!this._uiRoot.getComponent(Canvas)) {
            const canvas = this._uiRoot.addComponent(Canvas);
            if (this._uiCamera) {
                canvas.cameraComponent = this._uiCamera;
            }
        }

        // 遍历UILayer，初始化每一层
        for (let layer = UILayer.BACKGROUND; layer <= UILayer.LOADING; layer++) {
            let layerNode = this._uiRoot.getChildByName(UILayer[layer]);
            if (!layerNode) {
                layerNode = new Node(UILayer[layer]);
                this._uiRoot.addChild(layerNode);
                
                // 添加Widget组件，用于设置对齐模式
                const widget = layerNode.addComponent(Widget);
                widget.alignMode = Widget.AlignMode.ALWAYS;
                widget.left = widget.right = widget.top = widget.bottom = 0;
            }
            this._uiLayers.set(layer, layerNode);
        }
    }
}

// 导出UIManager类，继承自BaseModule，实现IWindowManager接口
export class UIManager extends BaseModule implements IWindowManager {
    // 定义私有变量，用于存储窗口管理器的数据、层管理器、UI根节点和UI相机
    private _dataManager: WindowManagerData = new WindowManagerData();
    private _layerManager: UILayerManager = new UILayerManager();
    private _uiRoot: Node | null = null;
    private _uiCamera: Camera | null = null;

    // 初始化方法，用于初始化UIManager
    init() {
        // 获取UIManager节点
        this._uiRoot = GameFramework.instance.node.getChildByName('UIManager');
        
        // 如果UIManager节点不存在，则创建UIManager节点并添加到GameFramework实例中
        if (!this._uiRoot) {
            this._uiRoot = new Node('UIManager');
            GameFramework.instance.addChild(this._uiRoot);
            
            // 创建UICamera节点并添加到UIManager节点中
            const cameraNode = new Node("UICamera");
            this._uiCamera = cameraNode.addComponent(Camera);
            this._uiCamera.priority = 1;
            this._uiRoot.addChild(cameraNode);
        } else {
            // 如果UIManager节点存在，则获取UICamera节点
            const cameraNode = this._uiRoot.getChildByName("UICamera");
            this._uiCamera = cameraNode?.getComponent(Camera) || null;
        }
        
        // 初始化层管理器，并设置UI根节点
        this._layerManager = new UILayerManager(this._uiRoot, this._uiCamera);
        this._layerManager.setUIRoot(this._uiRoot);
    }
    
    // 关闭方法，用于关闭UIManager
    shutdown(): void {
        // 关闭所有窗口
        this.closeAllWindows();
        // 将UI相机和UI根节点置为null
        this._uiCamera = null;
        this._uiRoot = null;
    }

    // 打开窗口方法，用于打开指定名称的窗口
    async openWindow(uiName: string, data?: IWindowData, options?: IWindowOptions): Promise<IWindowView | null> {
        try {
            // 获取UI根节点
            const uiRoot = this._layerManager.getUIRoot();
            if (!uiRoot) {
                console.error("UI Root is not set");
                return null;
            }

            // 如果窗口已经存在，则判断窗口是否已经打开，如果已经打开则显示窗口，否则打开窗口
            if (this._dataManager.hasWindow(uiName)) {
                const window = this._dataManager.getWindow(uiName)!;
                if (!window.isOpened()) {
                    window.open(data);
                    this._dataManager.pushToStack(window);
                } else {
                    window.show();
                }
                return window;
            }

            // 加载窗口预制体
            const prefabPath = `ui/${uiName}`;
            const prefab = await GameFramework.resource.load<Prefab>(prefabPath, Prefab);
            const node = instantiate(prefab);
            
            // 获取窗口脚本
            const script = node.getComponent(BaseWindow);
            if (!script) {
                console.error(`窗口 ${uiName} 缺少 BaseWindow 组件`);
                node.destroy();
                return null;
            }
            
            // 设置窗口层级
            const layer = options?.layer ?? UILayer.MAIN;
            script.setLayer(layer);
            script.setUIName(uiName);
            
            // 将窗口添加到对应的层级节点中
            const layerNode = this._layerManager.getLayerNode(layer);
            if (layerNode) {
                layerNode.addChild(node);
            } else if (uiRoot) {
                uiRoot.addChild(node);
            } else {
                GameFramework.instance.addChild(node);
            }
            
            // 初始化窗口并打开窗口
            script.init();
            this._dataManager.addWindow(uiName, script);
            script.open(data);
            this._dataManager.pushToStack(script);
            
            return script;
        } catch (error) {
            console.error(`打开窗口 ${uiName} 失败:`, error);
            return null;
        }
    }

    // 关闭窗口方法，用于关闭指定名称的窗口
    closeWindow(uiName: string): void {
        // 获取窗口
        const window = this._dataManager.getWindow(uiName);
        if (window) {
            // 关闭窗口并从栈中移除
            window.close();
            this._dataManager.removeFromStack(window);
            // 从数据管理器中移除窗口
            this._dataManager.removeWindow(uiName);
        }
    }

    // 关闭顶层窗口方法，用于关闭顶层窗口
    closeTopWindow(): void {
        // 获取顶层窗口
        const window = this._dataManager.popFromStack();
        if (window) {
            // 关闭顶层窗口
            window.close();
            // 注意：这里需要通过遍历找到对应的key删除
            const windows = this._dataManager.getAllWindows();
            for (const [key, value] of windows) {
                if (value === window) {
                    this._dataManager.removeWindow(key);
                    break;
                }
            }
        }
    }

    // 获取窗口方法，用于获取指定名称的窗口
    getWindow(uiName: string): IWindowView | undefined {
        // 从数据管理器中获取窗口
        return this._dataManager.getWindow(uiName);
    }

    // 关闭所有窗口方法，用于关闭所有窗口
    closeAllWindows(): void {
        // 关闭所有窗口
        this._dataManager.closeAllWindows();
    }

    // 显示消息框方法，用于显示消息框
    public async showMessage(
        title: string, 
        content: string, 
        onConfirm?: () => void, 
        onCancel?: () => void,
        showCancel: boolean = true
    ): Promise<void> {
        // 打开消息框窗口
        await this.openWindow("MessageBox", {
            title, content, onConfirm, onCancel, showCancel
        }, { layer: UILayer.POPUP });
    }

    // 显示输入框方法，用于显示输入框
    public async showInput(
        title: string,
        description: string,
        defaultValue: string,
        onConfirm?: (input: string) => void,
        onCancel?: () => void
    ): Promise<void> {
        // 打开输入框窗口
        await this.openWindow("InputBox", {
            title, description, defaultValue, onConfirm, onCancel
        }, { layer: UILayer.POPUP });
    }

    // 显示提示框方法，用于显示提示框
    public async showToast(
        message: string,
        duration: number = 2,
        type: string = "info"
    ): Promise<void> {
        // 打开提示框窗口
        await this.openWindow("Toast", {
            message, duration, type
        }, { layer: UILayer.TOOLTIP });
    }

    // 显示确认框方法，用于显示确认框
    public async showConfirm(
        title: string,
        content: string,
        onOk?: () => void,
        onNo?: () => void,
        onCancel?: () => void,
        showNo: boolean = true,
        showCancel: boolean = true
    ): Promise<void> {
        // 打开确认框窗口
        await this.openWindow("ConfirmDialog", {
            title, content, onOk, onNo, onCancel, showNo, showCancel
        }, { layer: UILayer.POPUP });
    }
}
